GNU Emacs Lisp Reference Manual

GNU Emacs Version 19

for Unix Users

Edition 2.0, May 1993

by Bil Lewis, Dan LaLiberte, Richard Stallman
and the GNU Manual Group

This is edition 2.0 of the GNU Emacs Lisp Reference Manual, for Emacs Version 19,
May 1993.
ISBN 1-882114-20-5.

Published by the Free Software Foundation,
675 Massachusetts Avenue,
Cambridge, MA 02139 USA

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.

Cover art by Etienne Suvasa.

Appendices
• Copying		Conditions for copying and changing GNU Emacs.
• Introduction		Introduction and conventions used.
• Types of Lisp Object		Data types in Emacs Lisp.
• Numbers		Numbers and arithmetic functions.
• Strings and Characters		Strings, and functions that work on them.
• Lists		Lists, cons cells, and related functions.
• Sequences Arrays Vectors		Lists, strings and vectors are called sequences. Certain functions act on any kind of sequence. The description of vectors is here as well.
• Symbols		Symbols represent names, uniquely.
• Evaluation		How Lisp expressions are evaluated.
• Control Structures		Conditionals, loops, nonlocal exits.
• Variables		Using symbols in programs to stand for values.
• Functions		A function is a Lisp program that can be invoked from other functions.
• Macros		Macros are a way to extend the Lisp language.
• Loading		Reading files of Lisp code into Lisp.
• Byte Compilation		Compilation makes programs run faster.
• Debugging		Tools and tips for debugging Lisp programs.
• Streams		Converting Lisp objects to text and back.
• Minibuffers		Using the minibuffer to read input.
• Command Loop		How the editor command loop works, and how you can call its subroutines.
• Keymaps		Defining the bindings from keys to commands.
• Modes		Defining major and minor modes.
• Documentation		Writing and using documentation strings.
• Files		Accessing files.
• Backups and Auto-Saving		Controlling how backups and auto-save files are made.
• Buffers		Creating and using buffer objects.
• Windows		Manipulating windows and displaying buffers.
• Frames		Making multiple X windows.
• Positions		Buffer positions and motion functions.
• Markers		Markers represent positions and update automatically when the text is changed.
• Text		Examining and changing text in buffers.
• Searching and Matching		Searching buffers for strings or regexps.
• Syntax Tables		The syntax table controls word and list parsing.
• Abbrevs		How Abbrev mode works, and its data structures.
• Processes		Running and communicating with subprocesses.
• System Interface		Getting the user id, system type, environment variables, and other such things.
• Emacs Display		Parameters controlling screen usage. The bell. Waiting for input.
• Calendar		Customizing the calendar and diary.
• Tips		Advice for writing Lisp programs.
• GNU Emacs Internals		Building and dumping Emacs; internal data structures.
• Standard Errors		List of all error symbols.
• Standard Buffer-Local Variables		List of variables local in all buffers.
• Standard Keymaps		List of standard keymaps.
• Standard Hooks		List of standard hook variables.
• Index		Index including concepts, functions, variables, and other terms.
— The Detailed Node Listing — Here are other nodes that are inferiors of those already listed, mentioned here so you can get to them in one step: Introduction
• Caveats		Flaws and a request for help.
• Lisp History		Emacs Lisp is descended from Maclisp.
• Conventions		How the manual is formatted.
• Acknowledgements		The authors, editors, and sponsors of this manual.
Conventions
• Some Terms		Explanation of terms we use in this manual.
• nil and t		How the symbols `nil` and `t` are used.
• Evaluation Notation		The format we use for examples of evaluation.
• Printing Notation		The format we use for examples that print output.
• Error Messages		The format we use for examples of errors.
• Buffer Text Notation		The format we use for buffer contents in examples.
• Format of Descriptions		Notation for describing functions, variables, etc.
Format of Descriptions
• A Sample Function Description
• A Sample Variable Description
Lisp Data Types
• Printed Representation		How Lisp objects are represented as text.
• Comments		Comments and their formatting conventions.
• Programming Types		Types found in all Lisp systems.
• Editing Types		Types specific to Emacs.
• Type Predicates		Tests related to types.
• Equality Predicates		Tests of equality between any two objects.
Programming Types
• Integer Type		Numbers without fractional parts.
• Floating Point Type		Numbers with fractional parts and with a large range.
• Character Type		The representation of letters, numbers and control characters.
• Sequence Type		Both lists and arrays are classified as sequences.
• List Type		Lists gave Lisp its name (not to mention reputation).
• Array Type		Arrays include strings and vectors.
• String Type		An (efficient) array of characters.
• Vector Type		One-dimensional arrays.
• Symbol Type		A multi-use object that refers to a function, variable, property list, or itself.
• Lisp Function Type		A piece of executable code you can call from elsewhere.
• Lisp Macro Type		A method of expanding an expression into another expression, more fundamental but less pretty.
• Primitive Function Type		A function written in C, callable from Lisp.
• Byte-Code Type		A function written in Lisp, then compiled.
• Autoload Type		A type used for automatically loading seldom-used functions.
List Type
• Dotted Pair Notation		An alternative syntax for lists.
• Association List Type		A specially constructed list.
Editing Types
• Buffer Type		The basic object of editing.
• Window Type		What makes buffers visible.
• Window Configuration Type		Save what the screen looks like.
• Marker Type		A position in a buffer.
• Process Type		A process running on the underlying OS.
• Stream Type		Receive or send characters.
• Keymap Type		What function a keystroke invokes.
• Syntax Table Type		What a character means.
Numbers
• Integer Basics		Representation and range of integers.
• Float Basics		Representation and range of floating point.
• Predicates on Numbers		Testing for numbers.
• Comparison of Numbers		Equality and inequality predicates.
• Arithmetic Operations		How to add, subtract, multiply and divide.
• Bitwise Operations		Logical and, or, not, shifting.
• Numeric Conversions		Converting float to integer and vice versa.
• Transcendental Functions		Trig, exponential and logarithmic functions.
• Random Numbers		Obtaining random integers, predictable or not.
Strings and Characters
• Intro to Strings		Basic properties of strings and characters.
• Predicates for Strings		Testing whether an object is a string or char.
• Creating Strings		Functions to allocate new strings.
• Text Comparison		Comparing characters or strings.
• String Conversion		Converting characters or strings and vice versa.
• Formatting Strings		`format`: Emacs’s analog of `printf`.
• Character Case		Case conversion functions.
Lists
• Cons Cells		How lists are made out of cons cells.
• Lists as Boxes		Graphical notation to explain lists.
• List-related Predicates		Is this object a list? Comparing two lists.
• List Elements		Extracting the pieces of a list.
• Building Lists		Creating list structure.
• Modifying Lists		Storing new pieces into an existing list.
• Sets And Lists		A list can represent a finite mathematical set.
• Association Lists		A list can represent a finite relation or mapping.
Modifying Existing List Structure
• Setcar		Replacing an element in a list.
• Setcdr		Replacing part of the list backbone. This can be used to remove or add elements.
• Rearrangement		Reordering the elements in a list; combining lists.
Sequences, Arrays, and Vectors
• Sequence Functions		Functions that accept any kind of sequence.
• Arrays		Characteristics of arrays in Emacs Lisp.
• Array Functions		Functions specifically for arrays.
• Vectors		Functions specifically for vectors.
Symbols
• Symbol Components		Symbols have names, values, function definitions and property lists.
• Definitions		A definition says how a symbol will be used.
• Creating Symbols		How symbols are kept unique.
• Property Lists		Each symbol has a property list for recording miscellaneous information.
Evaluation
• Intro Eval		Evaluation in the scheme of things.
• Eval		How to invoke the Lisp interpreter explicitly.
• Forms		How various sorts of objects are evaluated.
• Quoting		Avoiding evaluation (to put constants in the program).
Kinds of Forms
• Self-Evaluating Forms		Forms that evaluate to themselves.
• Symbol Forms		Symbols evaluate as variables.
• Classifying Lists		How to distinguish various sorts of list forms.
• Function Forms		Forms that call functions.
• Macro Forms		Forms that call macros.
• Special Forms		“Special forms” are idiosyncratic primitives, most of them extremely important.
• Autoloading		Functions set up to load files containing their real definitions.
Control Structures
• Sequencing		Evaluation in textual order.
• Conditionals		`if`, `cond`.
• Combining Conditions		`and`, `or`, `not`.
• Iteration		`while` loops.
• Nonlocal Exits		Jumping out of a sequence.
Nonlocal Exits
• Catch and Throw		Nonlocal exits for the program’s own purposes.
• Examples of Catch		Showing how such nonlocal exits can be written.
• Errors		How errors are signaled and handled.
• Cleanups		Arranging to run a cleanup form if an error happens.
Errors
• Signaling Errors		How to report an error.
• Processing of Errors		What Emacs does when you report an error.
• Handling Errors		How you can trap errors and continue execution.
• Error Names		How errors are classified for trapping them.
Variables
• Global Variables		Variable values that exist permanently, everywhere.
• Constant Variables		Certain "variables" have values that never change.
• Local Variables		Variable values that exist only temporarily.
• Void Variables		Symbols that lack values.
• Defining Variables		A definition says a symbol is used as a variable.
• Accessing Variables		Examining values of variables whose names are known only at run time.
• Setting Variables		Storing new values in variables.
• Variable Scoping		How Lisp chooses among local and global values.
• Buffer-Local Variables		Variable values in effect only in one buffer.
Scoping Rules for Variable Bindings
• Scope		Scope means where in the program a value is visible. Comparison with other languages.
• Extent		Extent means how long in time a value exists.
• Impl of Scope		Two ways to implement dynamic scoping.
• Using Scoping		How to use dynamic scoping carefully and avoid problems.
Buffer-Local Variables
• Intro to Buffer-Local		Introduction and concepts.
• Creating Buffer-Local		Creating and destroying buffer-local bindings.
• Default Value		The default value is seen in buffers that don’t have their own local values.
Functions
• What Is a Function		Lisp functions vs primitives; terminology.
• Lambda Expressions		How functions are expressed as Lisp objects.
• Function Names		A symbol can serve as the name of a function.
• Defining Functions		Lisp expressions for defining functions.
• Calling Functions		How to use an existing function.
• Mapping Functions		Applying a function to each element of a list, etc.
• Anonymous Functions		Lambda-expressions are functions with no names.
• Function Cells		Accessing or setting the function definition of a symbol.
• Related Topics		Cross-references to specific Lisp primitives that have a special bearing on how functions work.
Lambda Expressions
• Lambda Components		The parts of a lambda expression.
• Simple Lambda		A simple example.
• Argument List		Details and special features of argument lists.
• Function Documentation		How to put documentation in a function.
Macros
• Simple Macro		A basic example.
• Expansion		How, when and why macros are expanded.
• Compiling Macros		How macros are expanded by the compiler.
• Defining Macros		How to write a macro definition.
• Backquote		Easier construction of list structure.
• Problems with Macros		Don’t evaluate the macro arguments too many times. Don’t hide the user’s variables.
Loading
• How Programs Do Loading		The `load` function and others.
• Autoload		Setting up a function to autoload.
• Features		Loading a library if it isn’t already loaded.
• Repeated Loading		Precautions about loading a file twice.
Byte Compilation
• Compilation Functions		Byte compilation functions.
• Disassembly		Disassembling byte-code; how to read byte-code.
Debugging Lisp Programs
• Debugger		How the Emacs Lisp debugger is implemented.
• Syntax Errors		How to find syntax errors.
• Compilation Errors		How to find errors that show up in byte compilation.
The Lisp Debugger
• Error Debugging		Entering the debugger when an error happens.
• Function Debugging		Entering it when a certain function is called.
• Explicit Debug		Entering it at a certain point in the program.
• Using Debugger		What the debugger does; what you see while in it.
• Debugger Commands		Commands used while in the debugger.
• Invoking the Debugger		How to call the function `debug`.
• Internals of Debugger		Subroutines of the debugger, and global variables.
Debugging Invalid Lisp Syntax
• Excess Open		How to find a spurious open paren or missing close.
• Excess Close		How to find a spurious close paren or missing open.
Reading and Printing Lisp Objects
• Streams Intro		Overview of streams, reading and printing.
• Input Streams		Various data types that can be used as input streams.
• Input Functions		Functions to read Lisp objects from text.
• Output Streams		Various data types that can be used as output streams.
• Output Functions		Functions to print Lisp objects as text.
Minibuffers
• Intro to Minibuffers		Basic information about minibuffers.
• Text from Minibuffer		How to read a straight text string.
• Object from Minibuffer		How to read a Lisp object or expression.
• Completion		How to invoke and customize completion.
• Yes-or-No Queries		Asking a question with a simple answer.
• Minibuffer Misc		Various customization hooks and variables.
Completion
• Basic Completion		Low-level functions for completing strings. (These are too low level to use the minibuffer.)
• Programmed Completion		Finding the completions for a given file name.
• Minibuffer Completion		Invoking the minibuffer with completion.
• Completion Commands		Minibuffer commands that do completion.
• High-Level Completion		Convenient special cases of completion (reading buffer name, file name, etc.)
• Reading File Names		Using completion to read file names.
• Lisp Symbol Completion		Completing the name of a symbol.
Command Loop
• Command Overview		How the command loop reads commands.
• Defining Commands		Specifying how a function should read arguments.
• Interactive Call		Calling a command, so that it will read arguments.
• Command Loop Info		Variables set by the command loop for you to examine.
• Input Events		What input looks like when you read it.
• Reading Input		How to read input events from the keyboard or mouse.
• Waiting		Waiting for user input or elapsed time.
• Quitting		How `C-g` works. How to catch or defer quitting.
• Prefix Command Arguments		How the commands to set prefix args work.
• Recursive Editing		Entering a recursive edit, and why you usually shouldn’t.
• Disabling Commands		How the command loop handles disabled commands.
• Command History		How the command history is set up, and how accessed.
• Keyboard Macros		How keyboard macros are implemented.
Defining Commands
• Using Interactive		General rules for `interactive`.
• Interactive Codes		The standard letter-codes for reading arguments in various ways.
• Interactive Examples		Examples of how to read interactive arguments.
Keymaps
• Keymap Terminology		Definitions of terms pertaining to keymaps.
• Format of Keymaps		What a keymap looks like as a Lisp object.
• Creating Keymaps		Functions to create and copy keymaps.
• Inheritance and Keymaps		How one keymap can inherit the bindings of another keymap.
• Prefix Keys		Defining a key with a keymap as its definition.
• Menu Keymaps		A keymap can define a menu for X windows or for use from the terminal.
• Active Keymaps		Each buffer has a local keymap to override the standard (global) bindings. Each minor mode can also override them.
• Key Lookup		How extracting elements from keymaps works.
• Functions for Key Lookup		How to request key lookup.
• Changing Key Bindings		Redefining a key in a keymap.
• Key Binding Commands		Interactive interfaces for redefining keys.
• Scanning Keymaps		Looking through all keymaps, for printing help.
Major and Minor Modes
• Major Modes		Defining major modes.
• Minor Modes		Defining minor modes.
• Mode Line Format		Customizing the text that appears in the mode line.
• Hooks		How to use hooks; how to write code that provides hooks.
Major Modes
• Major Mode Conventions		Coding conventions for keymaps, etc.
• Example Major Modes		Text mode and Lisp modes.
• Auto Major Mode		How Emacs chooses the major mode automatically.
• Mode Help		Finding out how to use a mode.
Minor Modes
• Minor Mode Conventions		Tips for writing a minor mode.
• Keymaps and Minor Modes		How a minor mode can have its own keymap.
Mode Line Format
• Mode Line Data		The data structure that controls the mode line.
• Mode Line Variables		Variables used in that data structure.
• %-Constructs		Putting information into a mode line.
Documentation
• Documentation Basics		Good style for doc strings. Where to put them. How Emacs stores them.
• Accessing Documentation		How Lisp programs can access doc strings.
• Keys in Documentation		Substituting current key bindings.
• Describing Characters		Making printable descriptions of non-printing characters and key sequences.
• Help Functions		Subroutines used by Emacs help facilities.
Files
• Visiting Files		Reading files into Emacs buffers for editing.
• Saving Buffers		Writing changed buffers back into files.
• Reading from Files		Reading files into other buffers.
• Writing to Files		Writing new files from parts of buffers.
• File Locks		Locking and unlocking files, to prevent simultaneous editing by two people.
• Information about Files		Testing existence, accessibility, size of files.
• Contents of Directories		Getting a list of the files in a directory.
• Changing File Attributes		Renaming files, changing protection, etc.
• File Names		Decomposing and expanding file names.
Visiting Files
• Visiting Functions		The usual interface functions for visiting.
• Subroutines of Visiting		Lower-level subroutines that they use.
Information about Files
• Testing Accessibility		Is a given file readable? Writable?
• Kinds of Files		Is it a directory? A link?
• File Attributes		How large is it? Any other names? Etc.
File Names
• File Name Components		The directory part of a file name, and the rest.
• Directory Names		A directory’s name as a directory is different from its name as a file.
• Relative File Names		Some file names are relative to a current directory.
• File Name Expansion		Converting relative file names to absolute ones.
• Unique File Names		Generating names for temporary files.
• File Name Completion		Finding the completions for a given file name.
Backups and Auto-Saving
• Backup Files		How backup files are made; how their names are chosen.
• Auto-Saving		How auto-save files are made; how their names are chosen.
• Reverting		`revert-buffer`, and how to customize what it does.
Backup Files
• Making Backups		How Emacs makes backup files, and when.
• Rename or Copy		Two alternatives: renaming the old file or copying it.
• Numbered Backups		Keeping multiple backups for each source file.
• Backup Names		How backup file names are computed; customization.
Buffers
• Buffer Basics		What is a buffer?
• Buffer Names		Accessing and changing buffer names.
• Buffer File Name		The buffer file name indicates which file is visited.
• Buffer Modification		A buffer is modified if it needs to be saved.
• Modification Time		Determining whether the visited file was changed “behind Emacs’s back”.
• Read Only Buffers		Modifying text is not allowed in a read-only buffer.
• The Buffer List		How to look at all the existing buffers.
• Creating Buffers		Functions that create buffers.
• Killing Buffers		Buffers exist until explicitly killed.
• Current Buffer		Designating a buffer as current so primitives will access its contents.
Windows
• Basic Windows		Basic information on using windows.
• Splitting Windows		Splitting one window into two windows.
• Deleting Windows		Deleting a window gives its space to other windows.
• Selecting Windows		The selected window is the one that you edit in.
• Cyclic Window Ordering		Moving around the existing windows.
• Buffers and Windows		Each window displays the contents of a buffer.
• Displaying Buffers		Higher-lever functions for displaying a buffer and choosing a window for it.
• Window Point		Each window has its own location of point.
• Window Start		The display-start position controls which text is on-screen in the window.
• Vertical Scrolling		Moving text up and down in the window.
• Horizontal Scrolling		Moving text sideways on the window.
• Size of Window		Accessing the size of a window.
• Resizing Windows		Changing the size of a window.
• Window Configurations		Saving and restoring the state of the screen.
Positions
• Point		The special position where editing takes place.
• Motion		Changing point.
• Excursions		Temporary motion and buffer changes.
• Narrowing		Restricting editing to a portion of the buffer.
Motion
• Character Motion		Moving in terms of characters.
• Word Motion		Moving in terms of words.
• Buffer End Motion		Moving to the beginning or end of the buffer.
• Text Lines		Moving in terms of lines of text.
• Screen Lines		Moving in terms of lines as displayed.
• Vertical Motion		Implementation of `next-line` and `previous-line`.
• List Motion		Moving by parsing lists and sexps.
• Skipping Characters		Skipping characters belonging to a certain set.
Markers
• Overview of Markers		The components of a marker, and how it relocates.
• Predicates on Markers		Testing whether an object is a marker.
• Creating Markers		Making empty markers or markers at certain places.
• Information from Markers		Finding the marker’s buffer or character position.
• Changing Markers		Moving the marker to a new buffer or position.
• The Mark		How “the mark” is implemented with a marker.
• The Region		How to access “the region”.
Text
• Near Point		Examining text in the vicinity of point.
• Buffer Contents		Examining text in a general fashion.
• Insertion		Adding new text to a buffer.
• Commands for Insertion		User-level commands to insert text.
• Deletion		Removing text from a buffer.
• User-Level Deletion		User-level commands to delete text.
• The Kill Ring		Where removed text sometimes is saved for later use.
• Undo		Undoing changes to the text of a buffer.
• Auto Filling		How auto-fill mode is implemented to break lines.
• Filling		Functions for explicit filling.
• Sorting		Functions for sorting parts of the buffer.
• Indentation		Functions to insert or adjust indentation.
• Columns		Computing horizontal positions, and using them.
• Case Changes		Case conversion of parts of the buffer.
• Substitution		Replacing a given character wherever it appears.
• Underlining		Inserting or deleting underlining-by-overstrike.
• Registers		How registers are implemented. Accessing the text or position stored in a register.
The Kill Ring
• Kill Ring Concepts		What text looks like in the kill ring.
• Kill Functions		Functions that kill text.
• Yank Commands		Commands that access the kill ring.
• Low Level Kill Ring		Functions and variables for kill ring access.
• Internals of Kill Ring		Variables that hold kill-ring data.
Indentation
• Primitive Indent		Functions used to count and insert indentation.
• Mode-Specific Indent		Customize indentation for different modes.
• Region Indent		Indent all the lines in a region.
• Relative Indent		Indent the current line based on previous lines.
• Indent Tabs		Adjustable, typewriter-like tab stops.
• Motion by Indent		Move to first non-blank character.
Searching and Matching
• String Search		Search for an exact match.
• Regular Expressions		Describing classes of strings.
• Regexp Search		Searching for a match for a regexp.
• Match Data		Finding out which part of the text matched various parts of a regexp, after regexp search.
• Saving Match Data		Saving and restoring this information.
• Standard Regexps		Useful regexps for finding sentences, pages,...
• Searching and Case		Case-independent or case-significant searching.
Regular Expressions
• Syntax of Regexps		Rules for writing regular expressions.
• Regexp Example		Illustrates regular expression syntax.
Syntax Tables
• Syntax Descriptors		How characters are classified.
• Syntax Table Functions		How to create, examine and alter syntax tables.
• Parsing Expressions		Parsing balanced expressions using the syntax table.
• Standard Syntax Tables		Syntax tables used by various major modes.
• Syntax Table Internals		How syntax table information is stored.
Syntax Descriptors
• Syntax Class Table		Table of syntax classes.
• Syntax Flags		Additional flags each character can have.
Abbrevs And Abbrev Expansion
• Abbrev Mode		Setting up Emacs for abbreviation.
• Tables		Creating and working with abbrev tables.
• Defining Abbrevs		Specifying abbreviations and their expansions.
• Files		Saving abbrevs in files.
• Expansion		Controlling expansion; expansion subroutines.
• Standard Abbrev Tables		Abbrev tables used by various major modes.
Processes
• Subprocess Creation		Functions that start subprocesses.
• Synchronous Processes		Details of using synchronous subprocesses.
• Asynchronous Processes		Starting up an asynchronous subprocess.
• Deleting Processes		Eliminating an asynchronous subprocess.
• Process Information		Accessing run-status and other attributes.
• Input to Processes		Sending input to an asynchronous subprocess.
• Signals to Processes		Stopping, continuing or interrupting an asynchronous subprocess.
• Output from Processes		Collecting output from an asynchronous subprocess.
• Sentinels		Sentinels run when process run-status changes.
• TCP		Opening network connections.
Receiving Output from Processes
• Process Buffers		If no filter, output is put in a buffer.
• Filter Functions		Filter functions accept output from the process.
• Accepting Output		How to wait until process output arrives.
Operating System Interface
• Starting Up		Customizing Emacs start-up processing.
• Getting Out		How exiting works (permanent or temporary).
• System Environment		Distinguish the name and kind of system.
• Terminal Input		Recording terminal input for debugging.
• Terminal Output		Recording terminal output for debugging.
• Flow Control		How to turn output flow control on or off.
• Batch Mode		Running Emacs without terminal interaction.
Starting Up Emacs
• Start-up Summary		Sequence of actions Emacs performs at start-up.
• Init File		Details on reading the init file (‘`.emacs`’).
• Terminal-Specific		How the terminal-specific Lisp file is read.
• Command Line Arguments		How command line arguments are processed, and how you can customize them.
Getting out of Emacs
• Killing Emacs		Exiting Emacs irreversibly.
• Suspending Emacs		Exiting Emacs reversibly.
Emacs Display
• Refresh Screen		Clearing the screen and redrawing everything on it.
• Truncation		Folding or wrapping long text lines.
• The Echo Area		Where messages are displayed.
• Selective Display		Hiding part of the buffer text.
• Overlay Arrow		Display of an arrow to indicate position.
• Temporary Displays		Displays that go away automatically.
• Waiting		Forcing display update and waiting for user.
• Blinking		How Emacs shows the matching open parenthesis.
• Usual Display		How control characters are displayed.
• Beeping		Audible signal to the user.
• Window Systems		Which window system is being used.
GNU Emacs Internals
• Building Emacs		How to preload Lisp libraries into Emacs.
• Pure Storage		A kludge to make preloaded Lisp functions sharable.
• Garbage Collection		Reclaiming space for Lisp objects no longer used.
• Object Internals		Data formats of buffers, windows, processes.
• Writing Emacs Primitives		Writing C code for Emacs.
Object Internals
• Buffer Internals		Components of a buffer structure.
• Window Internals		Components of a window structure.
• Process Internals		Components of a process structure.

This document was generated on January 16, 2023 using texi2html 5.0.